package com.wei.czz.config;

import com.wei.czz.common.enums.rabbitMQ.MqEnum;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Created by IntelliJ IDEA.
 *
 * @author wyw
 * date: 2025-04-21 15:18:49
 * className: RabbitMQInitConfig 消息队列初始化配置类
 * version: 1.0
 * description:
 *  1、此类的作用是第一次启动项目时，自动将交换机和消息队列关系添加到rabbitmq服务中，避免手动添加，第一次启动成功后，可注释掉此类
 *  2、后续再添加新的交换机和消息队列时，只需要在类中添加对应的bean对象，然后重复第1步操作。
 */
//@Configuration
public class RabbitMQInitConfig {

    /**
     * 博客-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange blogDirect() {
        return new DirectExchange(MqEnum.Exchange.BLOG_DIRECT, true, false);
    }

    /**
     * 博客-扇形交换机
     *
     * @return 扇形交换机bean对象
     */
    @Bean
    public FanoutExchange blogFanout() {
        return new FanoutExchange(MqEnum.Exchange.BLOG_FANOUT, true, false);
    }

    /**
     * 系统导出/上传任务-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange taskDirect() {
        return new DirectExchange(MqEnum.Exchange.TASK_DIRECT, true, false);
    }

    /**
     * 游戏奖品/用户修改-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange gameDirect() {
        return new DirectExchange(MqEnum.Exchange.GAME_DIRECT, true, false);
    }

    /**
     * 死信-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange deadDirect() {
        return new DirectExchange(MqEnum.Exchange.DEAD_DIRECT, true, false);
    }

    /**
     * 用户关联角色-扇形交换机
     *
     * @return 扇形交换机bean对象
     */
//    @Bean
//    public FanoutExchange userRoleFanout() {
//        return new FanoutExchange(MqEnum.Exchange.USER_ROLE_FANOUT, true, false);
//    }

    /**
     * 角色授权组-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange roleSpaceDirect() {
        return new DirectExchange(MqEnum.Exchange.ROLE_SPACE_DIRECT, true, false);
    }

    /**
     * 角色-直连交换机
     *
     * @return 直连交换机bean对象
     */
    @Bean
    public DirectExchange roleDirect() {
        return new DirectExchange(MqEnum.Exchange.ROLE_DIRECT, true, false);
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    /**
     * 博客审核-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue blogAuditQueue() {
        return new Queue(MqEnum.Queue.BLOG_AUDIT, true, false, false);
    }

    /**
     * 博客评论-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue blogCommentQueue() {
        return new Queue(MqEnum.Queue.BLOG_COMMENT, true, false, false);
    }

    /**
     * 博客评论点赞-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue blogCommentLikeQueue() {
        return new Queue(MqEnum.Queue.BLOG_COMMENT_LIKE, true, false, false);
    }

    /**
     * 用户操作博客（点赞、收藏、浏览）-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue userBlogOptQueue() {
        return new Queue(MqEnum.Queue.USER_BLOG_OPT, true, false, false);
    }

    /**
     * 博客标签变化（增加、减少）-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue blogTagQueue() {
        return new Queue(MqEnum.Queue.BLOG_TAG, true, false, false);
    }

    /**
     * 博客状态变化-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue blogStatusQueue() {
        return new Queue(MqEnum.Queue.BLOG_STATUS, true, false, false);
    }

    /**
     * 系统导出任务-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue exportTaskQueue() {
        return new Queue(MqEnum.Queue.EXPORT_TASK, true, false, false);
    }

    /**
     * 系统导入任务-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue importTaskQueue() {
        return new Queue(MqEnum.Queue.IMPORT_TASK, true, false, false);
    }

    /**
     * 游戏用户-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue gameUserQueue() {
        return new Queue(MqEnum.Queue.GAME_USER, true, false, false);
    }

    /**
     * 游戏奖品-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue gamePrizeQueue() {
        return new Queue(MqEnum.Queue.GAME_PRIZE, true, false, false);
    }

    /**
     * 死信-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue deadQueue() {
        return new Queue(MqEnum.Queue.DEAD, true, false, false);
    }

    /**
     * 博客审核分组用户变更-消息队列
     *
     * @return 消息队列bean对象
     */
//    @Bean
//    public Queue blogAuditGroupUserModifyQueue() {
//        return new Queue(MqEnum.Queue.BLOG_AUDIT_GROUP_USER_MODIFY, true, false, false);
//    }

    /**
     * 部门关联角色变更-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue deptRoleQueue() {
        return new Queue(MqEnum.Queue.DEPT_ROLE, true, false, false);
    }

    /**
     * 部门用户关联角色变更-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue deptUserQueue() {
        return new Queue(MqEnum.Queue.DEPT_USER, true, false, false);
    }

    /**
     * 角色授权组关联角色变更-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue roleSpaceRoleQueue() {
        return new Queue(MqEnum.Queue.ROLE_SPACE_ROLE, true, false, false);
    }

    /**
     * 角色授权组关联用户变更-消息队列
     *
     * @return 消息队列bean对象
     */
    @Bean
    public Queue roleSpaceUserQueue() {
        return new Queue(MqEnum.Queue.ROLE_SPACE_USER, true, false, false);
    }

    /*----------------------------------------------------------------------------------------------------------------*/

    /**
     * 博客审核-交换机绑定消息队列
     *
     * @param blogAuditQueue 博客审核-消息队列
     * @param blogDirect     博客-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding blogAuditBinding(Queue blogAuditQueue, DirectExchange blogDirect) {
        return BindingBuilder.bind(blogAuditQueue).to(blogDirect).with(MqEnum.BLOG_AUDIT.getRoutingKey());
    }

    /**
     * 博客评论-交换机绑定消息队列
     *
     * @param blogCommentQueue 博客评论-消息队列
     * @param blogDirect       博客-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding blogCommentBinding(Queue blogCommentQueue, DirectExchange blogDirect) {
        return BindingBuilder.bind(blogCommentQueue).to(blogDirect).with(MqEnum.BLOG_COMMENT.getRoutingKey());
    }

    /**
     * 博客评论点赞-交换机绑定消息队列
     *
     * @param blogCommentLikeQueue 博客评论点赞-消息队列
     * @param blogDirect           博客-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding blogCommentLikeBinding(Queue blogCommentLikeQueue, DirectExchange blogDirect) {
        return BindingBuilder.bind(blogCommentLikeQueue).to(blogDirect).with(MqEnum.BLOG_COMMENT_LIKE.getRoutingKey());
    }

    /**
     * 用户操作博客（点赞、收藏、浏览）-交换机绑定消息队列
     *
     * @param userBlogOptQueue 用户操作博客（点赞、收藏、浏览）-消息队列
     * @param blogDirect       博客-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding userBlogOptBinding(Queue userBlogOptQueue, DirectExchange blogDirect) {
        return BindingBuilder.bind(userBlogOptQueue).to(blogDirect).with(MqEnum.USER_BLOG_OPT.getRoutingKey());
    }

    /**
     * 博客标签变化（增加、减少）-交换机绑定消息队列
     *
     * @param blogTagQueue 博客标签变化（增加、减少）-消息队列
     * @param blogFanout   博客-扇形交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding blogTagBinding(Queue blogTagQueue, FanoutExchange blogFanout) {
        return BindingBuilder.bind(blogTagQueue).to(blogFanout);
    }

    /**
     * 博客状态变化-交换机绑定消息队列
     *
     * @param blogStatusQueue 博客状态变化-消息队列
     * @param blogFanout      博客-扇形交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding blogStatusBinding(Queue blogStatusQueue, FanoutExchange blogFanout) {
        return BindingBuilder.bind(blogStatusQueue).to(blogFanout);
    }

    /**
     * 系统导出任务-交换机绑定消息队列
     *
     * @param exportTaskQueue 系统导出任务-消息队列
     * @param taskDirect      系统导出/上传任务-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding exportTaskBinding(Queue exportTaskQueue, DirectExchange taskDirect) {
        return BindingBuilder.bind(exportTaskQueue).to(taskDirect).with(MqEnum.EXPORT_TASK.getRoutingKey());
    }

    /**
     * 系统导入任务-交换机绑定消息队列
     *
     * @param importTaskQueue 系统导入任务-消息队列
     * @param taskDirect      系统导出/上传任务-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding importTaskBinding(Queue importTaskQueue, DirectExchange taskDirect) {
        return BindingBuilder.bind(importTaskQueue).to(taskDirect).with(MqEnum.IMPORT_TASK.getRoutingKey());
    }

    /**
     * 游戏用户-交换机绑定消息队列
     *
     * @param gameUserQueue 游戏用户-消息队列
     * @param gameDirect    游戏奖品/用户修改-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding gameUserBinding(Queue gameUserQueue, DirectExchange gameDirect) {
        return BindingBuilder.bind(gameUserQueue).to(gameDirect).with(MqEnum.GAME_USER.getRoutingKey());
    }

    /**
     * 游戏奖品-交换机绑定消息队列
     *
     * @param gamePrizeQueue 游戏奖品-消息队列
     * @param gameDirect     游戏奖品/用户修改-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding gamePrizeBinding(Queue gamePrizeQueue, DirectExchange gameDirect) {
        return BindingBuilder.bind(gamePrizeQueue).to(gameDirect).with(MqEnum.GAME_PRIZE.getRoutingKey());
    }

    /**
     * 死信-交换机绑定消息队列
     *
     * @param deadQueue 死信-消息队列
     * @param deadDirect 死信-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding deadBinding(Queue deadQueue, DirectExchange deadDirect) {
        return BindingBuilder.bind(deadQueue).to(deadDirect).with(MqEnum.DEAD.getRoutingKey());
    }

    /**
     * 部门关联角色-交换机绑定消息队列
     *
     * @param deptRoleQueue 部门关联角色变更-消息队列
     * @param roleDirect    角色-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding deptRoleBinding(Queue deptRoleQueue, DirectExchange roleDirect) {
        return BindingBuilder.bind(deptRoleQueue).to(roleDirect).with(MqEnum.DEPT_ROLE.getRoutingKey());
    }

    /**
     * 部门关联用户-交换机绑定消息队列
     *
     * @param deptUserQueue 部门用户关联角色变更-消息队列
     * @param roleDirect    角色-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding deptUserBinding(Queue deptUserQueue, DirectExchange roleDirect) {
        return BindingBuilder.bind(deptUserQueue).to(roleDirect).with(MqEnum.DEPT_USER.getRoutingKey());
    }

    /**
     * 角色授权组关联角色变更-交换机绑定消息队列
     *
     * @param roleSpaceRoleQueue 角色授权组关联角色变更-消息队列
     * @param roleSpaceDirect    角色授权组-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding roleSpaceRoleBinding(Queue roleSpaceRoleQueue, DirectExchange roleSpaceDirect) {
        return BindingBuilder.bind(roleSpaceRoleQueue).to(roleSpaceDirect).with(MqEnum.ROLE_SPACE_ROLE.getRoutingKey());
    }

    /**
     * 角色授权组关联用户变更-交换机绑定消息队列
     *
     * @param roleSpaceUserQueue 角色授权组关联用户变更-消息队列
     * @param roleSpaceDirect    角色授权组-直连交换机
     * @return 交换机绑定消息队列bean对象
     */
    @Bean
    public Binding roleSpaceUserBinding(Queue roleSpaceUserQueue, DirectExchange roleSpaceDirect) {
        return BindingBuilder.bind(roleSpaceUserQueue).to(roleSpaceDirect).with(MqEnum.ROLE_SPACE_USER.getRoutingKey());
    }
}
